package org.alwayssuper.protocol;

import org.alwayssuper.protostar.ProtostarUtil;
import org.alwayssuper.protocol.basics.GBTMessage;
import org.alwayssuper.protocol.gbt32960.*;

// Import 2025 version enums only (to avoid conflicts with 2016 version)
import org.alwayssuper.protocol.commons.transform.realtimev2025.enums.*;

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * GBT32960协议单元测试数据工厂
 * 参考JT808Beans设计，为各种协议消息创建标准测试数据
 * 支持2016版和2025版GB/T 32960.3标准
 * @author alwaysSuper
 * https://gitee.com/alwayssuper/gbt32960-server
 */
public class GBT32960Beans {

    // ==================== 测试常量定义 ====================
    public static final String DEVICE_ID = "LFPH2A1B0K1A12345";      // 车辆识别号
    public static final String VIN = "LSGGH52U4DG000001";             // 车辆识别代码
    public static final String ICCID = "89860123456789012345";        // ICCID号码
    public static final LocalDateTime TEST_TIME = LocalDateTime.of(2025, 8, 31, 14, 30, 0);
    public static final LocalDateTime START_TIME = LocalDateTime.of(2025, 8, 31, 0, 0, 0);
    public static final LocalDateTime END_TIME = LocalDateTime.of(2025, 8, 31, 23, 59, 59);
    
    // ==================== 通用工具方法 ====================
    
    /**
     * 创建标准的登入消息
     * @return G01登入消息
     */
    public static G01 G01_Login() {
        return H2025(G01_2025());
    }
    

    

    


    /** 2016版消息头 */
    public static <T extends GBTMessage> T H2016(T message) {
        message.setClientId(DEVICE_ID);
        message.setEncryptionType(0x01);
        message.setProtocolVersion(0);
        
        // 设置消息ID
        int messageId = message.reflectMessageId();
        if (messageId != 0) {
            message.setMessageId(messageId);
        }
        
        // 设置应答标识（0xFE表示命令包）
        message.setResponseType(0xFE);

        
        return message;
    }

    /** 2025版消息头 */
    public static <T extends GBTMessage> T H2025(T message) {
        message.setClientId(DEVICE_ID);
        message.setEncryptionType(0x01);
        message.setProtocolVersion(1);
        
        // 设置消息ID
        int messageId = message.reflectMessageId();
        if (messageId != 0) {
            message.setMessageId(messageId);
        }

        // 设置应答标识（0xFE表示命令包）
        message.setResponseType(0xFE);

        
        return message;
    }

    /**
     * G01 车辆登入消息 - 2016版本
     */
    public static G01 G01_2016() {
        G01 bean = new G01();
        bean.setCollectTime(TEST_TIME);
        bean.setLoginSeqNo(1);
        bean.setIccId("89860123456789012345");
        bean.setSubsysCount(2);
        bean.setSubsysCodeLen(0);

        
        return bean;
    }

    /**
     * G01 车辆登入消息 - 2025版本
     */
    public static G01 G01_2025() {
        G01 bean = new G01();
        bean.setCollectTime(TEST_TIME);
        bean.setLoginSeqNo(1);
        bean.setIccId("89860123456789012345");
        
        // 创建BMS电池包数量列表
        G01.BmsPackCountEntry bms1 = new G01.BmsPackCountEntry().setBatteryPackCount(2);
        G01.BmsPackCountEntry bms2 = new G01.BmsPackCountEntry().setBatteryPackCount(3);
        bean.setBmsPackCounts(Arrays.asList(bms1, bms2));
        
        // 创建电池包编码列表
        G01.BatteryPackEncoding pack1 = new G01.BatteryPackEncoding()
            .setBatteryPackCode("PACK00001234567890123456");
        G01.BatteryPackEncoding pack2 = new G01.BatteryPackEncoding()
            .setBatteryPackCode("PACK00002345678901234567");
        G01.BatteryPackEncoding pack3 = new G01.BatteryPackEncoding()
            .setBatteryPackCode("PACK00003456789012345678");
        G01.BatteryPackEncoding pack4 = new G01.BatteryPackEncoding()
            .setBatteryPackCode("PACK00004567890123456789");
        G01.BatteryPackEncoding pack5 = new G01.BatteryPackEncoding()
            .setBatteryPackCode("PACK00005678901234567890");
        bean.setBatteryPackEncodings(Arrays.asList(pack1, pack2, pack3, pack4, pack5));
        

        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本
     */
    public static G02 G02_2016() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        // 创建简单的实时数据
        Map<Integer, Object> realTimeData = new HashMap<>();
        // 这里需要根据实际的转换器实现来填充数据
        // 由于转换器比较复杂，这里先创建一个基本的结构
        bean.setRealTimeData(realTimeData);

        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2025版本
     */
    public static G02 G02_2025() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        // 创建简单的实时数据
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加签名数据 (2025版本特有)
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)  // SM2算法
                .setRValue(new byte[32])         // SM2 R值，32字节
                .setSValue(new byte[32]);        // SM2 S值，32字节
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);

        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本 (带Vehicle数据)
     */
    public static G02 G02_2016_WithVehicle() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        // 创建包含Vehicle数据的实时数据
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加整车数据 (信息类型0x01) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.Vehicle vehicle = new org.alwayssuper.protocol.commons.transform.realtimev2016.Vehicle()
            .setVehicleStatus(0x01)                    // 启动状态
            .setChargingStatus(0x03)                   // 未充电
            .setOperationMode(0x01)                    // 纯电模式
            .setDcDcStatus(0x01)                       // 工作状态
            .setGearPosition(0x23);                    // 前进3挡有驱动力
        
        // 使用转换方法设置真实值
        vehicle.setSpeed(65.0);                       // 65.0 km/h
        vehicle.setOdometer(123456.7);                // 123456.7 km
        vehicle.setTotalVoltage(480.0);               // 480.0 V
        vehicle.setTotalCurrent(15.0);                // 15.0 A
        vehicle.setSoc(85);                           // 85%
        vehicle.setInsulationResistance(5000);        // 5000 kΩ
        vehicle.setReserved(10);                      // 预留字段
            
        realTimeData.put(0x01, vehicle);
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本 (带DriveMotor数据)
     */
    public static G02 G02_2016_WithDriveMotor() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加驱动电机数据 (信息类型0x02)
        org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor driveMotor = new org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor();
        
        // 创建第一个电机信息
        org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor.MotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor.MotorInfo()
                .setMotorNumber(1)
                .setMotorStatus(0x01);                    // 耗电状态
        
        // 使用转换方法设置电机1真实值
        motor1.setControllerTemperature(35);              // 35℃
        motor1.setMotorSpeed(2000);                       // 2000 r/min
        motor1.setMotorTorque(150.0);                     // 150 N·m
        motor1.setMotorTemperature(45);                   // 45℃
        motor1.setInputVoltage(480.0);                    // 480.0 V
        motor1.setDcBusCurrent(15.0);                     // 15.0 A
        
        // 创建第二个电机信息
        org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor.MotorInfo motor2 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor.MotorInfo()
                .setMotorNumber(2)
                .setMotorStatus(0x02);                    // 发电状态
        
        // 使用转换方法设置电机2真实值
        motor2.setControllerTemperature(28);              // 28℃
        motor2.setMotorSpeed(5000);                       // 5000 r/min
        motor2.setMotorTorque(-22.0);                     // -22 N·m
        motor2.setMotorTemperature(32);                   // 32℃
        motor2.setInputVoltage(475.0);                    // 475.0 V
        motor2.setDcBusCurrent(-2.0);                     // -2.0 A
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2016.DriveMotor.MotorInfo> motorInfoList = Arrays.asList(motor1, motor2);
        
        driveMotor.setMotorInfoList(motorInfoList);
        realTimeData.put(0x02, driveMotor);
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本 (带VehiclePosition数据)
     */
    public static G02 G02_2016_WithVehiclePosition() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加车辆位置数据 (信息类型0x05) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.VehiclePosition vehiclePosition = new org.alwayssuper.protocol.commons.transform.realtimev2016.VehiclePosition()
            .setPositioningStatus(0x00);  // 有效定位，北纬，东经
        
        vehiclePosition.setLongitude(116.3987);           // 116.3987°经度
        vehiclePosition.setLatitude(39.9148);             // 39.9148°纬度
            
        realTimeData.put(0x05, vehiclePosition);
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本 (带ExtremeData数据)
     */
    public static G02 G02_2016_WithExtremeData() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加极值数据 (信息类型0x06) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.ExtremeData extremeData = new org.alwayssuper.protocol.commons.transform.realtimev2016.ExtremeData()
            .setMaxVoltageBatterySubsystemNo(1)     // 最高电压电池子系统号
            .setMaxVoltageBatteryCellNo(25)         // 最高电压电池单体代号
            .setMinVoltageBatterySubsystemNo(2)     // 最低电压电池子系统号
            .setMinVoltageBatteryCellNo(18)         // 最低电压电池单体代号
            .setMaxTempSubsystemNo(1)               // 最高温度子系统号
            .setMaxTempProbeNo(12)                  // 最高温度探针序号
            .setMinTempSubsystemNo(2)               // 最低温度子系统号
            .setMinTempProbeNo(5);                  // 最低温度探针序号
        
        // 使用转换方法设置真实值
        extremeData.setMaxBatteryCellVoltage(4.1);        // 4.1V电池单体电压最高值
        extremeData.setMinBatteryCellVoltage(3.95);       // 3.95V电池单体电压最低值
        extremeData.setMaxTemperature(45);                // 45℃最高温度值
        extremeData.setMinTemperature(15);                // 15℃最低温度值
            
        realTimeData.put(0x06, extremeData);
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2016版本 (多种消息体组合)
     */
    public static G02 G02_2016_WithMultipleDataTypes() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加整车数据 (信息类型0x01) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.Vehicle vehicle = new org.alwayssuper.protocol.commons.transform.realtimev2016.Vehicle()
            .setVehicleStatus(0x01)                    // 启动状态
            .setChargingStatus(0x03)                   // 未充电
            .setOperationMode(0x01)                    // 纯电模式
            .setDcDcStatus(0x01)                       // 工作状态
            .setGearPosition(0x25);                    // 前进5挡有驱动力

        // 使用转换方法设置真实值
        vehicle.setSpeed(80.0);                       // 80.0 km/h
        vehicle.setOdometer(98765.4);                 // 98765.4 km
        vehicle.setTotalVoltage(390.0);               // 390.0 V
        vehicle.setTotalCurrent(20.0);                // 20.0 A
        vehicle.setSoc(92);                           // 92%
        vehicle.setInsulationResistance(8500);        // 8500 kΩ
        vehicle.setReserved(0);                       // 预留字段
        realTimeData.put(0x01, vehicle);
        
        // 添加车辆位置数据 (信息类型0x05) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.VehiclePosition vehiclePosition = new org.alwayssuper.protocol.commons.transform.realtimev2016.VehiclePosition()
            .setPositioningStatus(0x00);  // 有效定位，北纬，东经
        
        vehiclePosition.setLongitude(121.4737);           // 121.4737°经度 (上海)
        vehiclePosition.setLatitude(31.2304);             // 31.2304°纬度 (上海)
        realTimeData.put(0x05, vehiclePosition);
        
        // 添加极值数据 (信息类型0x06) - 使用真实值，set方法内部转换
        org.alwayssuper.protocol.commons.transform.realtimev2016.ExtremeData extremeData = new org.alwayssuper.protocol.commons.transform.realtimev2016.ExtremeData()
            .setMaxVoltageBatterySubsystemNo(1)
            .setMaxVoltageBatteryCellNo(88)
            .setMinVoltageBatterySubsystemNo(3)
            .setMinVoltageBatteryCellNo(22)
            .setMaxTempSubsystemNo(2)
            .setMaxTempProbeNo(7)
            .setMinTempSubsystemNo(1)
            .setMinTempProbeNo(15);
        
        // 使用转换方法设置真实值
        extremeData.setMaxBatteryCellVoltage(4.05);       // 4.05V
        extremeData.setMinBatteryCellVoltage(3.98);       // 3.98V
        extremeData.setMaxTemperature(38);                // 38℃
        extremeData.setMinTemperature(22);                // 22℃
        realTimeData.put(0x06, extremeData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 实时信息上报消息 - 2025版本 (带Vehicle数据) - 基于真实业务场景
     */
    public static G02 G02_2025_WithVehicle() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        // 创建包含Vehicle数据的实时数据
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加整车数据 (信息类型0x01) - 使用真实转换方法设置数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())           // 启动状态
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())    // 未充电
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode());          // 纯电模式
                
        // 使用转换方法设置数据 - 真实行驶场景
        vehicle.setSpeed(72.5);                    // 实际车速72.5km/h
        vehicle.setOdometer(158963.2);             // 实际累计里程158963.2km
        vehicle.setTotalVoltage(387.6);            // 实际总电压387.6V
        vehicle.setTotalCurrent(28.3);             // 实际总电流28.3A (放电)
        vehicle.setSoc(78);                        // 实际SOC 78%
        vehicle.setInsulationResistance(12500);    // 实际绝缘电阻12500kΩ
        
        vehicle.setDcDcStatus(DcDcStatus.WORKING.getCode())                 // 工作状态
               .setGearPosition(GearStatus.AUTO_D.getCode());                // 自动D挡
            
        realTimeData.put(0x01, vehicle);
        
        // 添加签名数据 (2025版本特有)
        byte[] rValueData = new byte[32]; // 实际的R值数据
        for (int i = 0; i < 32; i++) {
            rValueData[i] = (byte) (0x12); // 填充测试数据
        }
        byte[] sValueData = new byte[32]; // 实际的S值数据  
        for (int i = 0; i < 32; i++) {
            sValueData[i] = (byte) (0x34); // 填充测试数据
        }
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)  // SM2算法
                .setRValue(rValueData)           // SM2 R值
                .setSValue(sValueData);          // SM2 S值
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);

        
        return bean;
    }

    /**
     * G03 补发信息上报消息 - 2016版本
     */
    public static G03 G03_2016() {
        G03 bean = new G03();
        bean.setCollectTime(TEST_TIME);
        
        // 创建简单的实时数据，与G02结构相同
        Map<Integer, Object> realTimeData = new HashMap<>();
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G03 补发信息上报消息 - 2025版本
     */
    public static G03 G03_2025() {
        G03 bean = new G03();
        bean.setCollectTime(TEST_TIME);
        
        // 创建简单的实时数据，与G02结构相同
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 添加签名数据 (2025版本特有)
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)  // SM2算法
                .setRValue(new byte[32])         // SM2 R值，32字节
                .setSValue(new byte[32]);        // SM2 S值，32字节
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        
        return bean;
    }

    /**
     * G04 车辆登出消息
     */
    public static G04 G04() {
        G04 bean = new G04();
        bean.setLogoutTime(TEST_TIME);
        bean.setLogoutSeqNo(100);
        
        
        return bean;
    }

    /**
     * G05 平台登入消息
     */
    public static G05 G05() {
        G05 bean = new G05();
        bean.setLoginTime(TEST_TIME);
        bean.setLoginSeqNo(1);
        bean.setPlatformUsername("platform_user");
        bean.setPlatformPassword("platform_pass");
        bean.setEncryptionRule(0x01);
        
        
        return bean;
    }

    /**
     * G06 平台登出消息
     */
    public static G06 G06() {
        G06 bean = new G06();
        bean.setLogoutTime(TEST_TIME);
        bean.setLogoutSeqNo(200);
        
        
        return bean;
    }

    /**
     * G0B 数据单元加密密钥交换消息 - RSA算法
     */
    public static G0B G0B_RSA() {
        G0B bean = new G0B();
        bean.setKeyType(G0B.KEY_TYPE_RSA);
//        bean.setKeyLength(256);
        bean.setEncryptionKey(new byte[256]); // RSA密钥数据
        bean.setEnableTime(START_TIME);
        bean.setExpireTime(END_TIME);
        
        
        return bean;
    }

    /**
     * G0B 数据单元加密密钥交换消息 - SM2算法
     */
    public static G0B G0B_SM2() {
        G0B bean = new G0B();
        bean.setKeyType(G0B.KEY_TYPE_SM2);
//        bean.setKeyLength(64);
        bean.setEncryptionKey(new byte[64]); // SM2密钥数据
        bean.setEnableTime(START_TIME);
        bean.setExpireTime(END_TIME);
        
        
        return bean;
    }

    /**
     * 通用应答消息
     */
    public static CommonResponse CommonResponse() {
        CommonResponse bean = new CommonResponse();
        bean.setSendTime(TEST_TIME);
        
        
        return bean;
    }

    // ==================== 详尽的实时信息上报测试案例 ====================

    /**
     * G02 完整的2025版实时信息上报 - 基于真实运营车辆数据
     */
    public static G02 G02_2025_Complete() {
        G02 bean = new G02();
        bean.setCollectTime(LocalDateTime.of(2025, 8, 30, 15, 30, 45));
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 1. 整车数据 (0x01) - 真实运营车辆高速行驶场景
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())           // 启动状态
                .setChargingStatus(ChargingStatus.DRIVING_CHARGING.getCode()) // 行驶充电
                .setOperationMode(RunMode.HYBRID.getCode())                  // 混动模式
                .setDcDcStatus(DcDcStatus.WORKING.getCode())                 // 工作状态
                .setGearPosition(GearStatus.AUTO_D.getCode());               // 自动D挡
                
        // 使用转换方法设置真实运营数据
        vehicle.setSpeed(89.7);                    // 实际车速89.7km/h (高速行驶)
        vehicle.setOdometer(267543.8);             // 实际累计里程267543.8km (运营车辆)
        vehicle.setTotalVoltage(652.3);            // 实际总电压652.3V (高压系统)
        vehicle.setTotalCurrent(-12.8);            // 实际总电流-12.8A (能量回收)
        vehicle.setSoc(67);                        // 实际SOC 67% (正常运行范围)
        vehicle.setInsulationResistance(18750);    // 实际绝缘电阻18750kΩ (良好状态)
        realTimeData.put(0x01, vehicle);
        
        // 2. 驱动电机数据 (0x02) - 运行时必选
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        // 创建双电机真实工况数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo frontMotor = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_CONSUMPTION.getCode()); // 前电机驱动
        
        // 使用转换方法设置前电机真实数据
        frontMotor.setControllerTemperature(68);      // 实际控制器温度68℃
        frontMotor.setDriveMotorSpeed(2875);          // 实际转速2875 r/min
        frontMotor.setDriveMotorTorque(185.6);        // 实际转矩185.6 N·m
        frontMotor.setDriveMotorTemperature(72);      // 实际电机温度72℃
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo rearMotor = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(2)
                .setDriveMotorStatus(DriveMotorStatus.POWER_GENERATION.getCode()); // 后电机回收
        
        // 使用转换方法设置后电机真实数据
        rearMotor.setControllerTemperature(58);       // 实际控制器温度58℃
        rearMotor.setDriveMotorSpeed(-1250);          // 实际转速-1250 r/min (制动回收)
        rearMotor.setDriveMotorTorque(-32.8);         // 实际转矩-32.8 N·m (制动扭矩)
        rearMotor.setDriveMotorTemperature(45);       // 实际电机温度45℃
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo> motorInfoList = Arrays.asList(
            frontMotor, rearMotor
        );
        motorData.setDriveMotorList(motorInfoList);
        realTimeData.put(0x02, motorData);
        
        // 3. 车辆位置数据 (0x05) - 真实GPS定位数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData locationData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData()
                .setPositionStatus(0x00)                                     // 有效定位
                .setCoordinateSystem(CoordinateSystem.GCJ02.getCode())      // GCJ02坐标系(国内常用)
                .setLongitude(121473856)          // 121.473856° (上海陆家嘴)
                .setLatitude(31235447);           // 31.235447° (真实商业区坐标)
        realTimeData.put(0x05, locationData);
        
        // 4. 报警数据 (0x06) - 真实运营中的轻微报警
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_1_FAULT.getCode())        // 1级报警(轻微)
                .setGeneralAlarmFlags(0x00000082); // SOC跳变报警 + 驱动电机温度报警
        
        // 真实故障代码设置
        alarmData.setBatteryFaultCodes(new int[]{})                          // 无电池故障
                 .setMotorFaultCodes(new int[]{0x02010001})                     // 电机温度预警
                 .setEngineFaultCodes(new int[]{})                              // 无发动机故障
                 .setOtherFaultCodes(new int[]{0x09010001})                     // 其他系统预警
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        // 5. 签名数据 (0xFF) - 2025版本必选
        byte[] rValueData = new byte[32]; // SM2 R值
        byte[] sValueData = new byte[32]; // SM2 S值
        for (int i = 0; i < 32; i++) {
            rValueData[i] = (byte) (0xA0 + (i % 16));
            sValueData[i] = (byte) (0xB0 + (i % 16));
        }
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)    // SM2算法
                .setRValue(rValueData)             // SM2 R值
                .setSValue(sValueData);            // SM2 S值
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 最小2025版实时信息上报 - 真实停车充电场景
     */
    public static G02 G02_2025_Minimal() {
        G02 bean = new G02();
        bean.setCollectTime(LocalDateTime.of(2025, 1, 1, 2, 15, 30)); // 深夜充电时间
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实停车充电场景数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STOPPED.getCode())           // 熄火状态
                .setChargingStatus(ChargingStatus.PARKED_CHARGING.getCode()) // 停车充电
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())           // 纯电模式
                .setDcDcStatus(DcDcStatus.WORKING.getCode())                 // DC-DC工作(为12V系统供电)
                .setGearPosition(GearStatus.PARK.getCode());                 // 停车挡
                
        // 使用转换方法设置真实充电数据
        vehicle.setSpeed(0.0);                      // 实际车速0 km/h (静止)
        vehicle.setOdometer(45678.3);               // 实际累计里程45678.3km
        vehicle.setTotalVoltage(401.2);             // 实际总电压401.2V (充电中)
        vehicle.setTotalCurrent(-45.7);             // 实际总电流-45.7A (充电电流)
        vehicle.setSoc(38);                         // 实际SOC 38% (充电中)
        vehicle.setInsulationResistance(22000);     // 实际绝缘电阻22000kΩ (充电状态良好)
        realTimeData.put(0x01, vehicle);
        
        // 签名数据 (2025版本必选)
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x03)    // ECC算法 (最小签名长度)
                .setRValue(new byte[20])           // ECC-P160最小长度
                .setSValue(new byte[20]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 最大2025版实时信息上报 - 真实极限运营场景
     */
    public static G02 G02_2025_Maximum() {
        G02 bean = new G02();
        bean.setCollectTime(LocalDateTime.of(2025, 12, 31, 23, 59, 59));
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实极限运营数据 - 重载货车高速场景
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())           // 启动状态
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())    // 未充电
                .setOperationMode(RunMode.HYBRID.getCode())                  // 混动模式
                .setDcDcStatus(DcDcStatus.WORKING.getCode())                 // 工作状态
                .setGearPosition(GearStatus.GEAR_8.getCode());               // 8挡(货车)
                
        // 使用转换方法设置极限运营数据
        vehicle.setSpeed(95.8);                     // 实际车速95.8km/h (货车限速)
        vehicle.setOdometer(892456.7);              // 实际累计里程892456.7km (重载运营)
        vehicle.setTotalVoltage(750.2);             // 实际总电压750.2V (重载系统)
        vehicle.setTotalCurrent(285.6);             // 实际总电流285.6A (重载放电)
        vehicle.setSoc(23);                         // 实际SOC 23% (低电量运营)
        vehicle.setInsulationResistance(8500);      // 实际绝缘电阻8500kΩ (重载状态)
        realTimeData.put(0x01, vehicle);
        
        // 真实极限运营报警数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_2_FAULT.getCode())        // 2级报警 (需关注)
                .setGeneralAlarmFlags(0x00E00014); // SOC低报警 + 绝缘电阻报警 + 电机控制器温度报警
        
        // 真实重载运营故障代码
        alarmData.setBatteryFaultCodes(new int[]{0x01030001})               // 电池SOC低预警
                 .setMotorFaultCodes(new int[]{0x02020001, 0x02020002})        // 电机控制器温度高、转矩输出受限
                 .setEngineFaultCodes(new int[]{})                              // 无发动机故障
                 .setOtherFaultCodes(new int[]{0x09040001})                     // 绝缘电阻预警
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        // 多种类型故障代码 (修复为使用int[]数组)
        alarmData.setBatteryFaultCodes(new int[]{0x41000001, 0x41000002})
                 .setMotorFaultCodes(new int[]{0x42000001})
                 .setEngineFaultCodes(new int[]{})           // 无发动机故障
                 .setOtherFaultCodes(new int[]{0x49000001})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障

        // 设置空的故障代码列表
        alarmData.setBatteryFaultCodes(new int[]{})          // 无电池故障
                 .setMotorFaultCodes(new int[]{})            // 无电机故障
                 .setEngineFaultCodes(new int[]{})           // 无发动机故障
                 .setOtherFaultCodes(new int[]{})            // 无其他故障
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        
        // 签名数据 - 最大长度 (RSA-2048)
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x02)    // RSA算法 (最大签名长度)
                .setRValue(new byte[256])          // RSA-2048最大长度
                .setSValue(new byte[256]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 异常值测试 - 包含异常和无效值
     */
    public static G02 G02_2025_WithExceptionalValues() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 包含异常值 - 使用枚举
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.ABNORMAL.getCode())          // 异常
                .setChargingStatus(ChargingStatus.INVALID.getCode())         // 无效
                .setOperationMode(RunMode.ABNORMAL.getCode())                // 异常
                .setDcDcStatus(DcDcStatus.ABNORMAL.getCode())                // 异常
                .setGearPosition(GearStatus.ABNORMAL.getCode());             // 异常
        
        // 使用原始传输值设置异常和无效状态
        vehicle.setSpeed(0xFFFE);                 // 异常
        vehicle.setOdometer(0xFFFFFFFF);          // 无效
        vehicle.setTotalVoltage(0xFFFE);          // 异常
        vehicle.setTotalCurrent(0xFFFE);          // 异常
        vehicle.setSoc(0xFF);                     // 无效
        vehicle.setInsulationResistance(0xFFFE);   // 异常
        realTimeData.put(0x01, vehicle);
        
        // 签名数据 - 正常
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)    // SM2算法
                .setRValue(new byte[32])           // SM2标准长度
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 2025版电池包电压数据测试 - 真实电动公交车电池系统
     */
    public static G02 G02_2025_WithBatteryVoltage() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实电动公交车电池系统数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData voltageData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData();
        
        // 第一个电池包 - 主动力电池包
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo pack1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo()
                .setBatteryPackId(1);
        
        // 使用转换方法设置真实电池包数据
        pack1.setBatteryPackVoltage(387.5);           // 实际电池包电压387.5V
        pack1.setBatteryPackCurrent(45.8);            // 实际电池包电流45.8A (放电)
        
        // 创建120个真实并联单元电压数据 (公交车电池系统)
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage> voltages1 = new java.util.ArrayList<>();
        for (int i = 0; i < 120; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage unit = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage();
            // 使用转换方法设置真实单体电压 (3.20-3.25V正常范围)
            unit.setParallelUnitVoltage(3.200 + (i % 50) * 0.001);
            voltages1.add(unit);
        }
        pack1.setParallelUnitVoltages(voltages1);
        
        // 第二个电池包 - 辅助动力电池包
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo pack2 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo()
                .setBatteryPackId(2);
        
        // 使用转换方法设置第二个电池包数据
        pack2.setBatteryPackVoltage(385.2);           // 实际电池包电压385.2V (略低)
        pack2.setBatteryPackCurrent(-8.5);            // 实际电池包电流-8.5A (微充电)
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage> voltages2 = new java.util.ArrayList<>();
        for (int i = 0; i < 120; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage unit = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage();
            // 辅助包电压略低且一致性较好 (3.18-3.22V)
            unit.setParallelUnitVoltage(3.180 + (i % 40) * 0.001);
            voltages2.add(unit);
        }
        pack2.setParallelUnitVoltages(voltages2);
        
        voltageData.setBatteryPackVoltageInfos(Arrays.asList(pack1, pack2));
        realTimeData.put(0x07, voltageData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 2025版电池温度数据测试 - 真实夏季运营温度监控
     */
    public static G02 G02_2025_WithBatteryTemperature() {
        G02 bean = new G02();
        bean.setCollectTime(LocalDateTime.of(2025, 7, 15, 14, 30, 0)); // 夏季高温时段
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实夏季运营电池温度监控数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData tempData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData();
        
        // 第一个电池包温度数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo pack1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo()
                .setBatteryPackNumber(1);
        
        // 创建24个温度探针的真实数据 (夏季高温场景)
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue> temps1 = new java.util.ArrayList<>();
        for (int i = 0; i < 24; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue temp = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue();
            // 使用转换方法设置真实温度 (夏季运营 32-38℃)
            temp.setTemperature(32 + (i % 6));
            temps1.add(temp);
        }
        pack1.setTemperatureValues(temps1);
        
        // 第二个电池包温度数据 (温度略高)
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo pack2 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo()
                .setBatteryPackNumber(2);
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue> temps2 = new java.util.ArrayList<>();
        for (int i = 0; i < 24; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue temp = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue();
            // 第二个包温度略高 (夏季运营 34-40℃)
            temp.setTemperature(34 + (i % 6));
            temps2.add(temp);
        }
        pack2.setTemperatureValues(temps2);
        
        tempData.setBatteryPackTempInfoList(Arrays.asList(pack1, pack2));
        realTimeData.put(0x08, tempData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    /**
     * G02 2025版超级电容器数据测试 - 真实有轨电车超级电容系统
     */
    public static G02 G02_2025_WithSupercapacitor() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实有轨电车超级电容系统数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData supercapData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData()
                .setSupercapacitorManagementSystemNo(1);
        
        // 使用转换方法设置真实总体数据
        supercapData.setTotalVoltage(875.6);           // 实际总电压875.6V (有轨电车系统)
        supercapData.setTotalCurrent(125.8);           // 实际总电流125.8A (制动回收)
        
        // 创建350个超级电容器单体真实电压数据
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage> cellVoltages = new java.util.ArrayList<>();
        for (int i = 0; i < 350; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage cell = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage();
            // 使用转换方法设置真实单体电压 (2.45-2.55V正常范围)
            cell.setCellVoltage(2.450 + (i % 100) * 0.001);
            cellVoltages.add(cell);
        }
        supercapData.setSupercapacitorCellVoltages(cellVoltages);
        
        // 创建16个温度探针的真实数据
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue> temperatures = new java.util.ArrayList<>();
        for (int i = 0; i < 16; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue temp = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue();
            // 使用转换方法设置真实温度 (有轨电车运营 28-35℃)
            temp.setTemperatureValue(28 + (i % 7));
            temperatures.add(temp);
        }
        supercapData.setTemperatureValues(temperatures);
        realTimeData.put(0x31, supercapData);
        
        // 超级电容器极值数据 (0x32) - 真实监控数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorExtremeData extremeData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorExtremeData()
                .setMaxVoltageSystemNo(1)          // 最高电压管理系统号
                .setMaxVoltageCellNo(158)          // 最高电压单体代号
                .setMinVoltageSystemNo(1)          // 最低电压管理系统号
                .setMinVoltageCellNo(73)           // 最低电压单体代号
                .setMaxTemperatureSystemNo(1)      // 最高温度管理系统号
                .setMaxTemperatureProbeNo(8)       // 最高温度探针代号
                .setMinTemperatureSystemNo(1)      // 最低温度管理系统号
                .setMinTemperatureProbeNo(14);     // 最低温度探针代号
        
        // 使用转换方法设置真实极值数据
        extremeData.setMaxVoltageValue(2.548);        // 实际最高电压2.548V
        extremeData.setMinVoltageValue(2.448);        // 实际最低电压2.448V
        extremeData.setMaxTemperatureValue(35);       // 实际最高温度35℃
        extremeData.setMinTemperatureValue(28);       // 实际最低温度28℃
        realTimeData.put(0x32, extremeData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        
        return bean;
    }

    // ==================== 2025版本枚举驱动测试用例 ====================
    
    /**
     * G02 2025版本枚举状态测试 - 真实日常通勤场景
     */
    public static G02 G02_2025_EnumStateTest() {
        G02 bean = new G02();
        bean.setCollectTime(LocalDateTime.of(2025, 6, 10, 8, 45, 20)); // 早高峰通勤时间
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 真实日常通勤车辆数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())           // 启动状态
                .setChargingStatus(ChargingStatus.CHARGING_COMPLETE.getCode()) // 充电完成
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())           // 纯电模式
                .setDcDcStatus(DcDcStatus.WORKING.getCode())                 // 工作状态
                .setGearPosition(GearStatus.AUTO_D.getCode());               // 自动D挡
                
        // 使用转换方法设置真实通勤数据
        vehicle.setSpeed(45.2);                    // 实际车速45.2km/h (城市道路)
        vehicle.setOdometer(28956.4);              // 实际累计里程28956.4km (私家车)
        vehicle.setTotalVoltage(398.7);            // 实际总电压398.7V (满电后)
        vehicle.setTotalCurrent(32.5);             // 实际总电流32.5A (加速阶段)
        vehicle.setSoc(92);                        // 实际SOC 92% (充满电后出行)
        vehicle.setInsulationResistance(18500);    // 实际绝缘电阻18500kΩ
        realTimeData.put(0x01, vehicle);
        
        // 真实单电机通勤数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_CONSUMPTION.getCode()); // 耗电驱动
        
        // 使用转换方法设置真实电机数据
        motor.setControllerTemperature(52);            // 实际控制器温度52℃
        motor.setDriveMotorSpeed(1850);                // 实际转速1850 r/min
        motor.setDriveMotorTorque(125.6);              // 实际转矩125.6 N·m
        motor.setDriveMotorTemperature(48);            // 实际电机温度48℃
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo> motorInfoList = Arrays.asList(motor);
        motorData.setDriveMotorList(motorInfoList);
        realTimeData.put(0x02, motorData);
        
        // 真实通勤路线GPS数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData locationData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData()
                .setPositionStatus(0x00)                                     // 有效定位
                .setCoordinateSystem(CoordinateSystem.GCJ02.getCode())      // GCJ02坐标系
                .setLongitude(116307245)          // 116.307245° (北京中关村)
                .setLatitude(39952847);           // 39.952847°
        realTimeData.put(0x05, locationData);
        
        // 日常通勤无报警数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.NO_FAULT.getCode())             // 无故障
                .setGeneralAlarmFlags(0x00000000); // 无报警标志
        
        // 设置空的故障代码列表
        alarmData.setBatteryFaultCodes(new int[]{})          // 无电池故障
                 .setMotorFaultCodes(new int[]{})            // 无电机故障
                 .setEngineFaultCodes(new int[]{})           // 无发动机故障
                 .setOtherFaultCodes(new int[]{})            // 无其他故障
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }
    
    /**
     * G02 2025版本热事件报警测试 - 最高级别热事件故障
     */
    public static G02 G02_2025_ThermalEventTest() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 车辆紧急状态 - 热事件故障
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.OTHER.getCode())             // 其他状态
                .setChargingStatus(ChargingStatus.ABNORMAL.getCode())        // 充电异常
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())           // 纯电模式
                .setDcDcStatus(DcDcStatus.DISCONNECTED.getCode())            // 断开状态
                .setGearPosition(GearStatus.PARK.getCode());                 // 停车挡
                
        // 使用转换方法设置真实紧急状态数据
        vehicle.setSpeed(0.0);                     // 实际车速0.0km/h (紧急停车)
        vehicle.setOdometer(888888.8);             // 实际累计里程888888.8km 
        vehicle.setTotalVoltage(0.0);              // 实际总电压0.0V (断电保护)
        vehicle.setTotalCurrent(0.0);              // 实际总电流0.0A
        vehicle.setSoc(15);                        // 实际SOC 15% (低电量)
        vehicle.setInsulationResistance(500);      // 实际绝缘电阻500kΩ (降低)
        realTimeData.put(0x01, vehicle);
        
        // 电机紧急状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.ABNORMAL.getCode());   // 异常状态
        
        // 使用转换方法设置真实电机过热数据
        motor.setControllerTemperature(210);           // 实际控制器温度210℃ (过热)
        motor.setDriveMotorSpeed(0);                   // 实际转速0 r/min (停止)
        motor.setDriveMotorTorque(0.0);                // 实际转矩0.0 N·m
        motor.setDriveMotorTemperature(210);           // 实际电机温度210℃ (过热)
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo> motorInfoList = Arrays.asList(motor);
        motorData.setDriveMotorList(motorInfoList);
        realTimeData.put(0x02, motorData);
        
        // 热事件报警 - 最高级别
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.THERMAL_EVENT_FAULT.getCode())  // 热事件故障
                .setGeneralAlarmFlags(0x00800003); // 热事件报警 + 温度差异报警 + 高温报警
        
        // 多种类型故障代码 (设置简单的整数数组)
        java.util.List<Integer> batteryFaults = new java.util.ArrayList<>();
        batteryFaults.add(0x41000001);
        batteryFaults.add(0x41000002);
        
        java.util.List<Integer> motorFaults = new java.util.ArrayList<>();
        motorFaults.add(0x42000001);
        
        java.util.List<Integer> otherFaults = new java.util.ArrayList<>();
        otherFaults.add(0x49000001);
        
        alarmData.setBatteryFaultCodes(new int[]{})
                 .setMotorFaultCodes(new int[]{})
                 .setEngineFaultCodes(new int[]{})           // 无发动机故障
                 .setOtherFaultCodes(new int[]{})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }
    
    /**
     * G02 2025版本多坐标系测试 - 不同坐标系的位置数据
     */
    public static G02 G02_2025_MultiCoordinateSystemTest() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 基本车辆数据 - 跨地区运行场景
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.GEAR_4.getCode());               // 4挡
                
        // 使用转换方法设置真实跨地区运行数据
        vehicle.setSpeed(60.0);                    // 实际车速60.0km/h
        vehicle.setOdometer(234567.8);             // 实际累计里程234567.8km
        vehicle.setTotalVoltage(380.0);            // 实际总电压380.0V
        vehicle.setTotalCurrent(10.0);             // 实际总电流10.0A
        vehicle.setSoc(68);                        // 实际SOC 68%
        vehicle.setInsulationResistance(15000);    // 实际绝缘电阻15000kΩ
        realTimeData.put(0x01, vehicle);
        
        // 特殊坐标系测试 - 其他坐标系
        org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData locationData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData()
                .setPositionStatus(0x00)                                     // 有效定位
                .setCoordinateSystem(CoordinateSystem.OTHER.getCode())      // 其他坐标系
                .setLongitude(113264400)          // 113.2644° (广州)
                .setLatitude(23129600);           // 23.1296°
        realTimeData.put(0x05, locationData);
        
        // 无报警状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.NO_FAULT.getCode())             // 无故障
                .setGeneralAlarmFlags(0x00000000); // 无报警
        
        // 设置空的故障代码列表
        alarmData.setBatteryFaultCodes(new int[]{})          // 无电池故障
                 .setMotorFaultCodes(new int[]{})            // 无电机故障
                 .setEngineFaultCodes(new int[]{})           // 无发动机故障
                 .setOtherFaultCodes(new int[]{})            // 无其他故障
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());   // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x03)    // ECC算法
                .setRValue(new byte[20])           // ECC较短长度
                .setSValue(new byte[20]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }
    
    /**
     * G02 2025版本档位特性测试 - 包含驱动力和制动力标志
     */
    public static G02 G02_2025_GearFeatureTest() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 车辆运行中状态 - 混动高速场景
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.HYBRID.getCode())                  // 混动模式
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.GEAR_6.getCode() | 0x20 | 0x10); // 6挡+驱动力+制动力
                
        // 使用转换方法设置真实混动高速数据
        vehicle.setSpeed(90.0);                    // 实际车速90.0km/h
        vehicle.setOdometer(345678.9);             // 实际累计里程345678.9km  
        vehicle.setTotalVoltage(450.0);            // 实际总电压450.0V
        vehicle.setTotalCurrent(20.0);             // 实际总电流20.0A
        vehicle.setSoc(82);                        // 实际SOC 82%
        vehicle.setInsulationResistance(18000);    // 实际绝缘电阻18000kΩ
        realTimeData.put(0x01, vehicle);
        
        // 双电机协同工作
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        // 前驱动电机 - 耗电驱动状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_CONSUMPTION.getCode()); // 耗电驱动
        
        // 使用转换方法设置真实前电机数据
        motor1.setControllerTemperature(65);           // 实际控制器温度65℃
        motor1.setDriveMotorSpeed(4000);               // 实际转速4000 r/min
        motor1.setDriveMotorTorque(250.0);             // 实际转矩250.0 N·m
        motor1.setDriveMotorTemperature(55);           // 实际电机温度55℃
        
        // 后驱动电机 - 发电回收状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor2 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(2)
                .setDriveMotorStatus(DriveMotorStatus.POWER_GENERATION.getCode()); // 发电回收
        
        // 使用转换方法设置真实后电机数据
        motor2.setControllerTemperature(48);           // 实际控制器温度48℃
        motor2.setDriveMotorSpeed(-4000);              // 实际转速-4000 r/min (反向)
        motor2.setDriveMotorTorque(-100.0);            // 实际转矩-100.0 N·m (制动)
        motor2.setDriveMotorTemperature(38);           // 实际电机温度38℃
        
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo> motorInfoList = Arrays.asList(motor1, motor2);
        motorData.setDriveMotorList(motorInfoList);
        realTimeData.put(0x02, motorData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x02)    // RSA算法
                .setRValue(new byte[128])          // RSA-1024
                .setSValue(new byte[128]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }
    
    /**
     * AlarmData单独测试 - 用于调试序列化问题
     * 2025版本只包含报警数据的最小测试案例
     */
    public static G02 G02_2025_AlarmOnlyTest() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME); // 设置数据采集时间
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 只添加报警数据进行测试
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_1_FAULT.getCode())        // 1级报警
                .setGeneralAlarmFlags(0x00000001); // 设置温度差异报警
        
        // 设置简单的故障代码列表进行测试
        alarmData.setBatteryFaultCodes(new int[]{0x01010001})               // 单个电池故障
                 .setMotorFaultCodes(new int[]{0x02010001})                     // 单个电机故障  
                 .setEngineFaultCodes(new int[]{})                               // 无发动机故障
                 .setOtherFaultCodes(new int[]{})                                // 无其他故障
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());       // 无通用报警故障
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    // ========== 详尽的G02实时上报场景数据 ==========

    /**
     * 车辆启动场景 - 从关闭到启动的完整过程
     */
    public static G02 G02_2025_VehicleStartupScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 启动中状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.PARKED_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.PARK.getCode());
        
        vehicle.setSpeed(0.0);              // 静止状态
        vehicle.setOdometer(12345.6);       // 历史里程
        vehicle.setTotalVoltage(380.2);     // 启动电压
        vehicle.setTotalCurrent(2.5);       // 启动电流
        vehicle.setSoc(78);                 // 电量充足
        vehicle.setInsulationResistance(15000); // 良好绝缘
        realTimeData.put(0x01, vehicle);
        
        // 驱动电机数据 - 待机状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.READY.getCode());
        
        motor1.setControllerTemperature(25);    // 常温
        motor1.setDriveMotorSpeed(0);           // 静止
        motor1.setDriveMotorTorque(0.0);        // 无扭矩
        motor1.setDriveMotorTemperature(28);    // 常温
        
        motorData.setDriveMotorList(Arrays.asList(motor1));
        realTimeData.put(0x02, motorData);
        
        // 位置数据 - 停车位置
        org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData locationData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData()
                .setPositionStatus(LocationStatus.PositioningValidity.VALID_POSITIONING.getCode())
                .setCoordinateSystem(CoordinateSystem.WGS84.getCode());
        
        locationData.setLongitude((int)(116.407412 * 1000000));  // 北京坐标，转换为百万分之一度
        locationData.setLatitude((int)(39.904030 * 1000000));
        realTimeData.put(0x05, locationData);
        
        // 报警数据 - 无报警
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.NO_FAULT.getCode())
                .setGeneralAlarmFlags(0x00000000);
        
        alarmData.setBatteryFaultCodes(new int[]{})
                 .setMotorFaultCodes(new int[]{})
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        // 签名数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData signatureData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SignatureData()
                .setSignatureType((byte) 0x01)
                .setRValue(new byte[32])
                .setSValue(new byte[32]);
        realTimeData.put(0xFF, signatureData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 充电场景 - 完整的充电过程数据
     */
    public static G02 G02_2025_ChargingScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 充电中状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STOPPED.getCode())
                .setChargingStatus(ChargingStatus.PARKED_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.PARK.getCode());
        
        vehicle.setSpeed(0.0);
        vehicle.setOdometer(15678.3);
        vehicle.setTotalVoltage(420.5);     // 充电电压
        vehicle.setTotalCurrent(-45.2);     // 充电电流(负值表示充入)
        vehicle.setSoc(65);                 // 充电中SOC
        vehicle.setInsulationResistance(18000);
        realTimeData.put(0x01, vehicle);
        
        // 电池包电压数据 - 充电过程中的电压分布
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData voltageData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo packInfo = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.BatteryPackVoltageInfo()
                .setBatteryPackId(1);
        
        packInfo.setBatteryPackVoltage(420.0);  // 使用真实值420.0V
        packInfo.setBatteryPackCurrent(-45.2);  // 使用真实值-45.2A
        
        // 模拟96个最小并联单元的电压
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage> voltageList = 
            new java.util.ArrayList<>();
        for (int i = 0; i < 96; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage voltage = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryPackVoltageData.ParallelUnitVoltage();
            voltage.setParallelUnitVoltage(4.18 + (i % 10) * 0.002); // 4.18V-4.2V范围
            voltageList.add(voltage);
        }
        packInfo.setParallelUnitVoltages(voltageList);
        
        voltageData.setBatteryPackVoltageInfos(Arrays.asList(packInfo));
        realTimeData.put(0x07, voltageData);
        
        // 电池温度数据 - 充电发热
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData tempData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo tempInfo = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo()
                .setBatteryPackNumber(1);
        
        // 模拟温度探针数据
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue> probeList = 
            new java.util.ArrayList<>();
        for (int i = 0; i < 16; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue probe = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue();
            probe.setTemperature(32 + i * 2); // 32°C-62°C充电发热
            probeList.add(probe);
        }
        tempInfo.setTemperatureValues(probeList);
        
        tempData.setBatteryPackTempInfoList(Arrays.asList(tempInfo));
        realTimeData.put(0x08, tempData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 高速行驶场景 - 高速公路行驶数据  
     */
    public static G02 G02_2025_HighSpeedDrivingScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 高速行驶状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(110.5);            // 高速行驶
        vehicle.setOdometer(89765.2);       // 高里程
        vehicle.setTotalVoltage(368.5);     // 放电电压
        vehicle.setTotalCurrent(125.8);     // 大电流放电
        vehicle.setSoc(42);                 // 电量消耗中
        vehicle.setInsulationResistance(12000);
        realTimeData.put(0x01, vehicle);
        
        // 驱动电机数据 - 高功率输出
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_CONSUMPTION.getCode());
        
        motor1.setControllerTemperature(75);        // 高温运行
        motor1.setDriveMotorSpeed(8500);            // 高转速
        motor1.setDriveMotorTorque(180.5);          // 高扭矩
        motor1.setDriveMotorTemperature(68);        // 电机发热
        
        motorData.setDriveMotorList(Arrays.asList(motor1));
        realTimeData.put(0x02, motorData);
        
        // 位置数据 - 高速移动
        org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData locationData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.VehicleLocationData()
                .setPositionStatus(LocationStatus.PositioningValidity.VALID_POSITIONING.getCode())
                .setCoordinateSystem(CoordinateSystem.GCJ02.getCode());
        
        locationData.setLongitude((int)(118.123456 * 1000000)); // 转换为百万分之一度
        locationData.setLatitude((int)(36.654321 * 1000000));
        realTimeData.put(0x05, locationData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 城市拥堵场景 - 频繁启停的城市驾驶
     */
    public static G02 G02_2025_UrbanTrafficScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 低速频繁启停
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(15.2);             // 低速行驶
        vehicle.setOdometer(25678.9);
        vehicle.setTotalVoltage(375.8);
        vehicle.setTotalCurrent(35.6);      // 中等功率
        vehicle.setSoc(58);
        vehicle.setInsulationResistance(14500);
        realTimeData.put(0x01, vehicle);
        
        // 能量回收频繁
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_GENERATION.getCode()); // 能量回收状态
        
        motor1.setControllerTemperature(45);
        motor1.setDriveMotorSpeed(-2000);       // 反向发电
        motor1.setDriveMotorTorque(-50.3);      // 制动扭矩
        motor1.setDriveMotorTemperature(42);
        
        motorData.setDriveMotorList(Arrays.asList(motor1));
        realTimeData.put(0x02, motorData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 低电量场景 - 电量不足报警和节能模式
     */
    public static G02 G02_2025_LowBatteryScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 低电量状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(45.0);
        vehicle.setOdometer(67890.1);
        vehicle.setTotalVoltage(320.5);     // 低电压
        vehicle.setTotalCurrent(28.5);      // 限制功率
        vehicle.setSoc(8);                  // 低电量！
        vehicle.setInsulationResistance(13000);
        realTimeData.put(0x01, vehicle);
        
        // 报警数据 - SOC低报警
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_1_FAULT.getCode())
                .setGeneralAlarmFlags(0x00000010); // SOC低报警
        
        alarmData.setBatteryFaultCodes(new int[]{0x01020001})   // SOC低预警
                 .setMotorFaultCodes(new int[]{})
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 多系统故障场景 - 并发故障诊断
     */
    public static G02 G02_2025_MultipleFaultsScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 故障状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.ABNORMAL.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(25.0);
        vehicle.setOdometer(45678.2);
        vehicle.setTotalVoltage(350.2);
        vehicle.setTotalCurrent(45.8);
        vehicle.setSoc(35);
        vehicle.setInsulationResistance(8500); // 绝缘电阻偏低
        realTimeData.put(0x01, vehicle);
        
        // 报警数据 - 多系统故障
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_2_FAULT.getCode())
                .setGeneralAlarmFlags(0x00008804); // 绝缘电阻+DC-DC温度+电机控制器温度报警
        
        alarmData.setBatteryFaultCodes(new int[]{0x01040001, 0x01040002})   // 电池温度高预警
                 .setMotorFaultCodes(new int[]{0x02030001})                 // 电机控制器故障
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{0x09030001})                 // DC-DC故障
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 极端温度场景 - 高低温环境测试  
     */
    public static G02 G02_2025_ExtremeTempScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 极端环境运行
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(60.0);
        vehicle.setOdometer(34567.8);
        vehicle.setTotalVoltage(365.8);
        vehicle.setTotalCurrent(85.2);
        vehicle.setSoc(48);
        vehicle.setInsulationResistance(11500);
        realTimeData.put(0x01, vehicle);
        
        // 电池温度数据 - 极端温度
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData tempData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo tempInfo = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryPackTempInfo()
                .setBatteryPackNumber(1);
        
        // 模拟极端温度分布
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue> probeList = 
            new java.util.ArrayList<>();
        for (int i = 0; i < 12; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue probe = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.BatteryTemperatureData.BatteryTemperatureValue();
            if (i < 6) {
                probe.setTemperature(-15 + i * 2); // -15°C到-5°C低温
            } else {
                probe.setTemperature(55 + (i - 6) * 5); // 55°C到85°C高温
            }
            probeList.add(probe);
        }
        tempInfo.setTemperatureValues(probeList);
        
        tempData.setBatteryPackTempInfoList(Arrays.asList(tempInfo));
        realTimeData.put(0x08, tempData);
        
        // 报警数据 - 温度报警
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_1_FAULT.getCode())
                .setGeneralAlarmFlags(0x00000003); // 温度差异+电池高温报警
        
        alarmData.setBatteryFaultCodes(new int[]{0x01050001})   // 电池温度异常
                 .setMotorFaultCodes(new int[]{})
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 能量回收场景 - 制动能量回收过程
     */
    public static G02 G02_2025_EnergyRecoveryScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 制动回收中
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.DRIVING_CHARGING.getCode()) // 行驶充电
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(35.5);
        vehicle.setOdometer(23456.7);
        vehicle.setTotalVoltage(385.2);
        vehicle.setTotalCurrent(-25.8);     // 负电流表示回收
        vehicle.setSoc(72);                 // SOC上升中
        vehicle.setInsulationResistance(16000);
        realTimeData.put(0x01, vehicle);
        
        // 驱动电机数据 - 发电状态
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData motorData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData();
        
        org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo motor1 = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.DriveMotorData.DriveMotorInfo()
                .setDriveMotorSequence(1)
                .setDriveMotorStatus(DriveMotorStatus.POWER_GENERATION.getCode());
        
        motor1.setControllerTemperature(38);
        motor1.setDriveMotorSpeed(-3500);       // 反向发电
        motor1.setDriveMotorTorque(-85.5);      // 制动扭矩
        motor1.setDriveMotorTemperature(35);
        
        motorData.setDriveMotorList(Arrays.asList(motor1));
        realTimeData.put(0x02, motorData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 停车场景 - 车辆停车熄火过程
     */
    public static G02 G02_2025_ParkingScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 停车熄火
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STOPPED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.DISCONNECTED.getCode())
                .setGearPosition(GearStatus.PARK.getCode());
        
        vehicle.setSpeed(0.0);
        vehicle.setOdometer(56789.4);
        vehicle.setTotalVoltage(378.5);     // 静态电压
        vehicle.setTotalCurrent(0.2);       // 微小待机电流
        vehicle.setSoc(55);
        vehicle.setInsulationResistance(17500);
        realTimeData.put(0x01, vehicle);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 燃料电池混动场景 - 燃料电池+电池混合动力
     */
    public static G02 G02_2025_FuelCellHybridScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 混动模式
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.HYBRID.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.AUTO_D.getCode());
        
        vehicle.setSpeed(80.0);
        vehicle.setOdometer(78901.5);
        vehicle.setTotalVoltage(395.8);
        vehicle.setTotalCurrent(95.6);
        vehicle.setSoc(45);
        vehicle.setInsulationResistance(14000);
        realTimeData.put(0x01, vehicle);
        
        // 燃料电池发动机数据
        org.alwayssuper.protocol.commons.transform.realtimev2025.FuelCellEngineData fuelCellData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.FuelCellEngineData()
                .setMaxTemperatureProbeNo(1)
                .setMaxHydrogenConcentrationSensorNo(1)
                .setMaxHydrogenPressureSensorNo(1);
        
        fuelCellData.setMaxTemperatureInHydrogenSystem(78);    // 使用真实值78°C
        fuelCellData.setMaxHydrogenConcentration(1.25);        // 使用真实值1.25%
        fuelCellData.setMaxHydrogenPressure(85.0);             // 使用真实值85.0 MPa
        fuelCellData.setHighVoltageDcDcStatus(0x01);           // 工作
        fuelCellData.setRemainingHydrogenPercentage(75);       // 75%
        fuelCellData.setDcDcControllerTemperature(65);         // 使用真实值65°C
        
        realTimeData.put(0x03, fuelCellData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 超级电容场景 - 超级电容快充放电
     */
    public static G02 G02_2025_SupercapacitorScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 超级电容数据 - 快速充放电
        org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData supercapData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData()
                .setSupercapacitorManagementSystemNo(1);
        
        supercapData.setTotalVoltage(850.2);           // 使用真实值850.2V
        supercapData.setTotalCurrent(180.5);           // 使用真实值180.5A
        
        // 超级电容单体电压列表
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage> cellVoltages = 
            new java.util.ArrayList<>();
        for (int i = 0; i < 10; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage cellVoltage = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.SupercapacitorCellVoltage();
            cellVoltage.setCellVoltage(85000 + i * 10); // 85V 左右
            cellVoltages.add(cellVoltage);
        }
        supercapData.setSupercapacitorCellVoltages(cellVoltages);
        
        // 温度探针数据
        java.util.List<org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue> tempValues = 
            new java.util.ArrayList<>();
        for (int i = 0; i < 5; i++) {
            org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue tempValue = 
                new org.alwayssuper.protocol.commons.transform.realtimev2025.SupercapacitorData.TemperatureValue();
            tempValue.setTemperatureValue(75 + i); // 35°C-39°C (75-79 - 40)
            tempValues.add(tempValue);
        }
        supercapData.setTemperatureValues(tempValues);
        
        realTimeData.put(0x31, supercapData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 远程诊断场景 - 远程维护和诊断数据
     */
    public static G02 G02_2025_RemoteDiagnosticsScenario() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 诊断模式
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(VehicleStatus.STARTED.getCode())
                .setChargingStatus(ChargingStatus.NOT_CHARGING.getCode())
                .setOperationMode(RunMode.PURE_ELECTRIC.getCode())
                .setDcDcStatus(DcDcStatus.WORKING.getCode())
                .setGearPosition(GearStatus.PARK.getCode());
        
        vehicle.setSpeed(0.0);
        vehicle.setOdometer(125678.9);      // 高里程车辆
        vehicle.setTotalVoltage(372.8);
        vehicle.setTotalCurrent(1.8);       // 诊断待机电流
        vehicle.setSoc(68);
        vehicle.setInsulationResistance(13500);
        realTimeData.put(0x01, vehicle);
        
        // 详细故障代码 - 维护建议
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(AlarmLevel.LEVEL_1_FAULT.getCode())
                .setGeneralAlarmFlags(0x00000000); // 无实时报警
        
        // 历史故障记录用于诊断
        alarmData.setBatteryFaultCodes(new int[]{0x01060001, 0x01060002}) // 电池老化预警
                 .setMotorFaultCodes(new int[]{0x02040001})               // 电机磨损预警
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{0x09050001})               // 系统维护提醒
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 数据完整性测试 - 所有字段边界值验证
     */
    public static G02 G02_2025_DataIntegrityTest() {
        G02 bean = new G02();
        bean.setCollectTime(TEST_TIME);
        Map<Integer, Object> realTimeData = new HashMap<>();
        
        // 整车数据 - 边界值测试
        org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle vehicle = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.Vehicle()
                .setVehicleStatus(0xFE)             // 异常值
                .setChargingStatus(0xFF)            // 无效值
                .setOperationMode(0xFE)             // 异常值
                .setDcDcStatus(0xFF)                // 无效值
                .setGearPosition(0xFE);             // 异常值
        
        vehicle.setSpeed(0xFFFE);                   // 异常值
        vehicle.setOdometer(0xFFFFFFFE);           // 异常值  
        vehicle.setTotalVoltage(0xFFFE);           // 异常值
        vehicle.setTotalCurrent(0xFFFE);           // 异常值
        vehicle.setSoc(0xFE);                      // 异常值
        vehicle.setInsulationResistance(0xFFFE);   // 异常值
        realTimeData.put(0x01, vehicle);
        
        // 报警数据 - 边界值
        org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData alarmData = 
            new org.alwayssuper.protocol.commons.transform.realtimev2025.AlarmData()
                .setMaxAlarmLevel(0xFE)             // 异常值
                .setGeneralAlarmFlags(0xFFFFFFFE);  // 异常值
        
        alarmData.setBatteryFaultCodes(new int[]{})
                 .setMotorFaultCodes(new int[]{})
                 .setEngineFaultCodes(new int[]{})
                 .setOtherFaultCodes(new int[]{})
                 .setGeneralAlarmFaultLevels(new java.util.ArrayList<>());
        realTimeData.put(0x06, alarmData);
        
        bean.setRealTimeData(realTimeData);
        return bean;
    }

    /**
     * 获取测试用例描述
     */
    public static void printTestCaseDescriptions() {
        System.out.println("=== GBT32960 实时信息上报测试用例说明 ===");
        System.out.println("G02_2025_Complete()      - 完整2025版，包含所有信息体类型");
        System.out.println("G02_2025_Minimal()       - 最小2025版，仅必需信息体");
        System.out.println("G02_2025_Maximum()       - 最大2025版，边界值测试");
        System.out.println("G02_2025_WithExceptionalValues() - 异常值测试");
        System.out.println("G02_2025_WithBatteryVoltage()    - 电池包电压数据测试");
        System.out.println("G02_2025_WithBatteryTemperature() - 电池温度数据测试");
        System.out.println("G02_2025_WithSupercapacitor()     - 超级电容器数据测试");
        System.out.println();
        System.out.println("=== 2025版本枚举驱动测试用例 ===");
        System.out.println("G02_2025_EnumStateTest()         - 车辆各种工作状态枚举测试");
        System.out.println("G02_2025_ThermalEventTest()      - 最高级别热事件故障测试");
        System.out.println("G02_2025_MultiCoordinateSystemTest() - 多坐标系位置数据测试");
        System.out.println("G02_2025_GearFeatureTest()       - 档位特性(驱动力/制动力)测试");
        System.out.println();
        System.out.println("=== 详尽场景测试用例 ===");
        System.out.println("G02_2025_AlarmOnlyTest()         - AlarmData序列化单独测试");
        System.out.println("G02_2025_VehicleStartupScenario() - 车辆启动场景测试");
        System.out.println("G02_2025_ChargingScenario()      - 完整充电过程测试");
        System.out.println("G02_2025_HighSpeedDrivingScenario() - 高速公路行驶场景");
        System.out.println("G02_2025_UrbanTrafficScenario()  - 城市拥堵频繁启停场景");
        System.out.println("G02_2025_LowBatteryScenario()    - 低电量报警和节能模式");
        System.out.println("G02_2025_MultipleFaultsScenario() - 多系统并发故障诊断");
        System.out.println("G02_2025_ExtremeTempScenario()   - 极端高低温环境测试");
        System.out.println("G02_2025_EnergyRecoveryScenario() - 制动能量回收过程");
        System.out.println("G02_2025_ParkingScenario()       - 停车熄火场景测试");
        System.out.println("G02_2025_FuelCellHybridScenario() - 燃料电池混动场景");
        System.out.println("G02_2025_SupercapacitorScenario() - 超级电容快充放电");
        System.out.println("G02_2025_RemoteDiagnosticsScenario() - 远程诊断维护数据");
        System.out.println("G02_2025_DataIntegrityTest()     - 数据完整性边界值验证");
        System.out.println();
        System.out.println("=== 兼容性和性能测试 ===");
        System.out.println("testG02_ProtocolCompatibilityTest() - 2016版与2025版协议兼容性");
        System.out.println("testG02_2025_PerformanceStressTest() - 性能压力测试(100次序列化)");
        System.out.println();
        System.out.println("使用方法：");
        System.out.println("G02 testCase = GBT32960Beans.H2025(GBT32960Beans.G02_2025_ChargingScenario());");
        System.out.println("System.out.println(\"测试数据: \" + testCase.getRealTimeData().size() + \" 个信息体\");");
        System.out.println();
        System.out.println("枚举使用示例：");
        System.out.println("VehicleStatus.STARTED.getCode()              // 启动状态 0x01");
        System.out.println("ChargingStatus.PARKED_CHARGING_COMPLETE.getCode()   // 充电完成 0x04");
        System.out.println("AlarmLevel.THERMAL_EVENT_FAULT.getCode()     // 热事件故障 4");
        System.out.println("CoordinateSystem.GCJ02.getCode()             // GCJ02坐标系 0x02");
        System.out.println();
        System.out.println("=== 场景说明 ===");
        System.out.println("车辆启动: 从停车状态到启动的完整过程，包含待机电机和位置信息");
        System.out.println("充电场景: 完整充电过程，包含电池包电压分布和充电温度变化");
        System.out.println("高速驾驶: 高功率输出状态，高转速电机和GPS高速移动数据");
        System.out.println("城市拥堵: 频繁启停，能量回收状态和低速行驶特征");
        System.out.println("低电量: SOC报警状态，限制功率输出和节能模式");
        System.out.println("多重故障: 并发系统故障，包含电池、电机、DC-DC等多重报警");
        System.out.println("极端温度: 高低温环境下的电池热管理和温度分布");
        System.out.println("能量回收: 制动回收过程，负扭矩和充电状态");
        System.out.println("燃料电池: 混合动力模式，燃料电池和氢系统数据");
        System.out.println("超级电容: 快速充放电特性和高功率密度应用");
        System.out.println("远程诊断: 维护预警和历史故障分析数据");
        System.out.println("数据完整性: 异常值和边界值的正确处理验证");
    }

    // ==================== 其他GBT协议消息工厂方法 ====================




}